This PR cuts a number of per-request/per-stream costs on the HTTP/2 server hot path, in two commits.

1. http2: reduce per-request allocations

• Track 'priority'/'frameError' stream listeners by overriding the EventEmitter methods on Http2Stream instead of subscribing to 'newListener'/'removeListener'. The previous approach made every listener add/remove on every stream emit an extra tracking event (the compat layer alone adds 11 listeners per request).
• buildNgHeaderString: replace the per-call SafeSet with a lazily allocated array, skip the sensitive-headers map() when there are none (the common case), and skip the HTTP-token regex plus connection-specific-header checks for well-known single-value header names — they are all valid tokens and none of them is connection-specific.
• Replace per-call closures with shared named handlers in onStreamClose (natural close path), afterShutdown and Http2Stream._destroy.
• Skip the pendingStreams Set add/delete for streams created with their native handle already available (all server streams).
• Hoist the per-request onStreamTimeout closure factories in the compat layer, and avoid a once() wrapper allocation per server stream.

2. http2: skip trailers round trip for compat responses

The compat layer always responded with waitForTrailers set, so every response paid for a wantTrailers C++ → JS callback, an empty sendTrailers() submission scheduled through setImmediate(), and an extra empty DATA frame on the wire — even though the vast majority of responses never register trailers.

When the headers are flushed as part of response.end() and no trailers have been registered, there is no further opportunity to add trailers, so waitForTrailers is now skipped. Headers flushed early (writeHead(), write(), flushHeaders()) keep the previous behavior, so trailers can still be added while streaming.

Behavior note for reviewers: trailers added after response.end() are now silently dropped. This matches HTTP/1 response.addTrailers() semantics (docs updated accordingly).

3. http2: avoid per-write closures in kWriteGeneric

Every _write()/_writev() allocated four closures plus an anonymous nextTick callback to coordinate the write callback with the end-of-stream check. Since the stream machinery dispatches at most one write at a time, that state now lives on the stream's kState object with shared named functions. When trailers are pending, the end-of-stream check tick is skipped entirely (the writable side cannot be shut down early anyway). Also pre-initializes the dynamically-added kState fields (shutdownWritableCalled, fd) so hot-path stores no longer transition the object shape.

4. http2: finish empty trailers natively for compat streams

Compat responses that flush headers before end() (writeHead()/write()/flushHeaders()) must keep waitForTrailers, so they paid a wantTrailers C++ → JS callback, an empty sendTrailers() + setImmediate(), and a trailers() call back into C++ on every response. A new internal STREAM_OPTION_AUTO_EMPTY_TRAILERS lets C++ finish the stream itself (same empty DATA + END_STREAM frame, identical wire format) when JS never registered trailers; a later setTrailer() flips the stream back to JS-managed trailers via a new disableAutoTrailers() binding, so streaming trailers work unchanged (regression test added). Compat writeHead()+end(): +5.0% vs the previous commit (47.8k → 50.2k req/s, 8 alternating runs); multi-write streaming ~+1%.

5. http2: reduce scheduled callbacks per request

The end-of-stream check (which merges END_STREAM into the final DATA frame) was a process.nextTick() on every write; when the write is dispatched from inside end() — the common end(chunk) case — an end() override now runs the check synchronously after the base method returns. And the setImmediate() scheduled on every stream destruction to poke Http2Session[kMaybeDestroy] is now gated on the only condition where it isn't a no-op (session closed, no remaining streams); session.close() and the native ongracefulclosecomplete notification cover the other paths. Wire format verified byte-identical. Consistently ~+1% across 42 paired samples (within single-run noise).

6. http2: avoid copying the options in respond()

Drops the per-response { ...options } clone (respond only reads the options now) and picks up :status/date while copying the response headers instead of re-reading them from the dictionary-mode copy. Throughput-neutral on its own; removes an object clone and several dictionary lookups per response.

Benchmarks

h2load (-c 4 -m 100, 1 KiB payload, mean of 6 alternating runs):

benchmark/compare.js (10 runs):

http2/headers.js nheaders=0 n=1000            **      3.98 %       ±2.79%
http2/headers.js nheaders=10 n=1000          ***      7.11 %       ±3.32%
http2/headers.js nheaders=100 n=1000                  1.67 %       ±1.73%
http2/headers.js nheaders=1000 n=1000                -0.32 %       ±1.26%

http2/compat.js duration=5 benchmarker='h2load' clients=2 streams=100 requests=5000    3.02 %  ±4.95%
http2/write.js  duration=5 benchmarker='h2load' size=100000 length=131072 streams=100  1.66 %  ±8.59%

(compat.js/write.js/simple.js stream a file from fs per request, so they are dominated by file streaming and mostly insensitive to per-request overhead; no regressions.)